package maple.thelittleredbook.interaction.service;

import lombok.extern.slf4j.Slf4j;
import maple.thelittleredbook.interaction.entity.Like;
import maple.thelittleredbook.interaction.entity.UserBehavior;
import maple.thelittleredbook.interaction.mapper.LikeMapper;
import maple.thelittleredbook.interaction.mapper.UserBehaviorMapper;
import maple.thelittleredbook.recommendation.service.UserProfileUpdateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;


/**
 * 异步用户行为处理服务
 * 负责异步记录用户行为、更新统计数据和用户画像
 */
@Slf4j
@Service
public class AsyncUserBehaviorService {

    private final UserBehaviorMapper userBehaviorMapper;
    private final LikeMapper likeMapper;
    private final UserProfileUpdateService userProfileUpdateService;

    @Autowired
    public AsyncUserBehaviorService(UserBehaviorMapper userBehaviorMapper,
                                    LikeMapper likeMapper,
                                    UserProfileUpdateService userProfileUpdateService) {
        this.userBehaviorMapper = userBehaviorMapper;
        this.likeMapper = likeMapper;
        this.userProfileUpdateService = userProfileUpdateService;
    }


    /**
     * 异步处理浏览行为
     * 对外接口 - 供其他模块调用
     *
     * @param userId 用户ID
     * @param contentId 内容ID
     */
    @Async
    public void processViewBehaviorAsync(Long userId, Long contentId) {
        try {
            log.debug("开始处理浏览行为，用户ID: {}, 内容ID: {}", userId, contentId);

            // 1. 先更新用户画像（在记录行为之前检查冷却期）
            boolean profileUpdated = userProfileUpdateService.updateProfileByView(userId, contentId);
            if (profileUpdated) {
                log.debug("浏览行为画像更新成功，用户ID: {}, 内容ID: {}", userId, contentId);
            } else {
                log.debug("浏览行为画像更新跳过（冷却期或其他原因），用户ID: {}, 内容ID: {}", userId, contentId);
            }

            // 2. 记录用户行为
            recordUserBehavior(userId, contentId, "VIEW");

            // 3. 更新内容浏览量
            updateContentViewCount(contentId);

        } catch (Exception e) {
            log.error("处理浏览行为时发生异常，用户ID: {}, 内容ID: {}", userId, contentId, e);
        }
    }

    /**
     * 异步处理评论行为
     * 对外接口 - 供其他模块调用
     *
     * @param userId 用户ID
     * @param contentId 内容ID
     */
    @Async
    public void processCommentBehaviorAsync(Long userId, Long contentId) {
        try {
            log.debug("开始处理评论行为，用户ID: {}, 内容ID: {}", userId, contentId);

            // 1. 先更新用户画像（在记录行为之前检查冷却期）
            boolean profileUpdated = userProfileUpdateService.updateProfileByComment(userId, contentId);
            if (profileUpdated) {
                log.debug("评论行为画像更新成功，用户ID: {}, 内容ID: {}", userId, contentId);
            } else {
                log.debug("评论行为画像更新跳过（冷却期或其他原因），用户ID: {}, 内容ID: {}", userId, contentId);
            }

            // 2. 记录用户行为
            recordUserBehavior(userId, contentId, "COMMENT");

            // 3. 更新内容评论量
            updateContentCommentCount(contentId);

        } catch (Exception e) {
            log.error("处理评论行为时发生异常，用户ID: {}, 内容ID: {}", userId, contentId, e);
        }
    }

    /**
     * 异步处理踩行为
     * 对外接口 - 供其他模块调用
     *
     * @param userId 用户ID
     * @param contentId 内容ID
     */
    @Async
    public void processDislikeBehaviorAsync(Long userId, Long contentId) {
        try {
            log.debug("开始处理踩行为，用户ID: {}, 内容ID: {}", userId, contentId);

            // 1. 先更新用户画像（在记录行为之前检查）
            boolean profileUpdated = userProfileUpdateService.updateProfileByDislike(userId, contentId);
            if (profileUpdated) {
                log.debug("踩行为画像更新成功，用户ID: {}, 内容ID: {}", userId, contentId);
            } else {
                log.debug("踩行为画像更新失败，用户ID: {}, 内容ID: {}", userId, contentId);
            }

            // 2. 记录用户行为
            recordUserBehavior(userId, contentId, "DISLIKE");

        } catch (Exception e) {
            log.error("处理踩行为时发生异常，用户ID: {}, 内容ID: {}", userId, contentId, e);
        }
    }

    /**
     * 查询用户对目标对象的点赞状态
     * 对外接口 - 供其他业务模块调用
     *
     * @param userId 用户ID
     * @param targetId 目标ID（内容ID或评论ID）
     * @param targetType 目标类型（CONTENT 或 COMMENT）
     * @return 点赞记录，如果未点赞则返回null
     */
    public Like getLikeStatus(Long userId, Long targetId, String targetType) {
        try {
            log.debug("查询点赞状态，用户ID: {}, 目标ID: {}, 目标类型: {}", userId, targetId, targetType);

            Like likeStatus = likeMapper.selectLikeByUserAndTarget(userId, targetId, targetType);

            if (likeStatus != null) {
                log.debug("用户已点赞，用户ID: {}, 目标ID: {}, 目标类型: {}", userId, targetId, targetType);
            } else {
                log.debug("用户未点赞，用户ID: {}, 目标ID: {}, 目标类型: {}", userId, targetId, targetType);
            }

            return likeStatus;

        } catch (Exception e) {
            log.error("查询点赞状态失败，用户ID: {}, 目标ID: {}, 目标类型: {}", userId, targetId, targetType, e);
            return null;
        }
    }


    /**
     * 异步处理内容点赞行为（处理用户行为记录和画像更新）
     */
    @Async
    protected void processLikeBehaviorAsync(Long userId, Long contentId) {
        try {
            // 1. 先更新用户画像（在记录行为之前检查冷却期）
            boolean profileUpdated = userProfileUpdateService.updateProfileByLike(userId, contentId);
            if (profileUpdated) {
                log.debug("点赞行为画像更新成功，用户ID: {}, 内容ID: {}", userId, contentId);
            } else {
                log.debug("点赞行为画像更新跳过（冷却期或其他原因），用户ID: {}, 内容ID: {}", userId, contentId);
            }

            // 2. 记录用户行为（无论画像是否更新都要记录）
            recordUserBehavior(userId, contentId, "LIKE");

        } catch (Exception e) {
            log.error("异步处理点赞行为失败，用户ID: {}, 内容ID: {}", userId, contentId, e);
        }
    }

    /**
     * 异步处理内容取消点赞行为（处理用户行为记录和画像更新）
     */
    @Async
    protected void processUnlikeBehaviorAsync(Long userId, Long contentId) {
        try {
            // 1. 先更新用户画像（在记录行为之前检查冷却期）
            boolean profileUpdated = userProfileUpdateService.updateProfileByUnlike(userId, contentId);
            if (profileUpdated) {
                log.debug("取消点赞行为画像更新成功，用户ID: {}, 内容ID: {}", userId, contentId);
            } else {
                log.debug("取消点赞行为画像更新跳过（冷却期或其他原因），用户ID: {}, 内容ID: {}", userId, contentId);
            }

            // 2. 记录用户行为（无论画像是否更新都要记录）
            recordUserBehavior(userId, contentId, "UNLIKE");

        } catch (Exception e) {
            log.error("异步处理取消点赞行为失败，用户ID: {}, 内容ID: {}", userId, contentId, e);
        }
    }


    private void recordUserBehavior(Long userId, Long contentId, String behaviorType) {
        try {
            UserBehavior userBehavior = new UserBehavior();
            userBehavior.setUserId(userId);
            userBehavior.setContentId(contentId);
            userBehavior.setBehaviorType(behaviorType);

            userBehaviorMapper.insert(userBehavior);
            log.debug("用户行为记录成功，用户ID: {}, 内容ID: {}, 行为类型: {}", userId, contentId, behaviorType);

        } catch (Exception e) {
            log.error("记录用户行为失败，用户ID: {}, 内容ID: {}, 行为类型: {}", userId, contentId, behaviorType, e);
        }
    }

    /**
     * 更新内容浏览量
     */
    private void updateContentViewCount(Long contentId) {
        try {
            int updateCount = userBehaviorMapper.updateContentViewCount(contentId);
            if (updateCount > 0) {
                log.debug("内容浏览量更新成功，内容ID: {}", contentId);
            } else {
                log.warn("内容浏览量更新失败，可能内容不存在，内容ID: {}", contentId);
            }
        } catch (Exception e) {
            log.error("更新内容浏览量失败，内容ID: {}", contentId, e);
        }
    }


    /**
     * 更新内容评论量
     */
    private void updateContentCommentCount(Long contentId) {
        try {
            int updateCount = userBehaviorMapper.updateContentCommentCount(contentId);
            if (updateCount > 0) {
                log.debug("内容评论量更新成功，内容ID: {}", contentId);
            } else {
                log.warn("内容评论量更新失败，可能内容不存在，内容ID: {}", contentId);
            }
        } catch (Exception e) {
            log.error("更新内容评论量失败，内容ID: {}", contentId, e);
        }
    }
}